/**
 * Diese Klasse Vergleicht zwei Auswertungsobjekte.<br>
 * Diese Klasse vergleicht zwei Auswertungsobjekte und stellt <br>
 * ein neues Auswertungsobjekt bereit, dass den Vergleich der<br>
 * Beiden wiedergibt.<br>
 * @author M. Czekala
 * @see Auswertung
 */

public class Vergleich {

	private Auswertung A1;
	private Auswertung A2;
	private Auswertung diff;
	private double[] schnitte;
	private double[] maxErlos; 
	
	/**
	 * Konstruktor.<br>
	 * @param a, Auswertung der Kostenfunktion
	 * @param b, Auswertung der Erloesfunktion
	 */
	public Vergleich(Auswertung a, Auswertung b)
	{
		A1 = a;
		A2 = b;
		erstelleDiff();
		schnitte = diff.getNst();
		berechneMaxEr();
	}
	
	
	//berechnet die differenzfunktion indem erloes - kosten gerechnet wird.
    private void erstelleDiff()
    {
        //f1 = kosten; f2 = erloes;
        double[][] ubergabe = new double[A1.getWerte().length][2];
        //Testausgabe zum pruefen der Laenge
//        System.out.println("Vergleich -- A1 Laenge: " + A1.getWerte().length); 
//        System.out.println("Vergleich -- A2 Laenge:	" + A2.getWerte().length);
//        System.out.println("Vergleich -- uebergabe Laenge: " + ubergabe.length);
//        System.out.println("A1: x=" + A1.getWerte()[A1.getWerte().length][0] + "; y=" + A1.getWerte()[A1.getWerte().length-1][1]);
//        System.out.println("A2: x=" + A2.getWerte()[A2.getWerte().length][0] + "; y=" + A2.getWerte()[A2.getWerte().length-1][1]);

        for(int i = 0; i < A1.getWerte().length; i++)//laeuft von 0 bis l-1... >.<
        {
            ubergabe[i][0] = A1.getWerte()[i][0]; // x wert wird immer kopiert
            if(Double.isNaN(A1.getWerte()[i][1]) || Double.isNaN(A2.getWerte()[i][1]))
            {// falls y nicht definiert ist, ist es in der diff auch nicht definiert
            	ubergabe[i][1] = Double.NaN;
            }
            else
            {// sonst:
            	ubergabe[i][1] = A2.getWerte()[i][1] - A1.getWerte()[i][1]; //erloes - kosten!
            }
            
          //Testausgabe zum Puefen der Werte
          //System.out.println("Vergleich -- Difffunktion: "+ i + " - " + ubergabe[i][1]);
            
        }//wertetabelle der difffunktion erstellt!
        diff = new Auswertung(ubergabe);
        //System.out.println("diff: x=" + diff.getWerte()[diff.getWerte().length-1][0] + "; y=" + diff.getWerte()[diff.getWerte().length-1][1]);
        //System.out.println("Vergleich -- diff Laenge: " + diff.getWerte().length);
    }

	
	//sucht den positivsten wert in den extremas
	private void berechneMaxEr()
	{
		maxErlos = new double[2];
		if(diff.getExt().length == 0)//sollte eig nicht vorkommen...
		{
			maxErlos[0] = Double.NaN;
			maxErlos[1] = Double.NaN;
		}
		else
		{
			//Testausgabe
			//System.out.println("diff l'nge: " + diff.getExt().length);
			maxErlos[0] = diff.getExt()[0][0];
			maxErlos[1] = diff.getExt()[0][1];
			for(int i=0; i < diff.getExt().length; i++)
			{
				System.out.println("MaxErl: x=" + maxErlos[0] + ", y=" + maxErlos[1]);
				System.out.println("Vergleich: diff ext: x=" + diff.getExt()[i][0] + ", y=" + diff.getExt()[i][1]);
				if(maxErlos[1] <= diff.getExt()[i][1])
				{//x und y wert uebertragen
					maxErlos[0] = diff.getExt()[i][0];
					maxErlos[1] = diff.getExt()[i][1];
				}
				//Testausgabe
				//System.out.println("MaxErl: x=" + maxErlos[0] + ", y=" + maxErlos[1]);
			}
		}
	}
	
	
	
	/*
	 * Getter-Methoden
	 */
	
	/**
	 * Liefert die Kostenfunktion.<br>
	 * @return Auswertung der Kostenfunktion.
	 */
	public Auswertung getKostenfunktion()
	{
		return A1;
	}
	
	/**
	 * Liefert die Erloesfunktion.<br>
	 * @return Auswertung der Erloesfunktion.
	 */
	public Auswertung getErloesfunktion()
	{
		return A2;
	}
	
	/**
	 * Liefert die Differenzfunktion.<br>
	 * @return Auswertung der Differenzfunktion.
	 */
	public Auswertung getDiffFunktion()
	{
		return diff;
	}
	
	
	/**
	 * Liefert die Schnittstellen der beiden Auswertungen.<br>
	 * @return ein Array mit den X Werten der Schnittpunkte.
	 */
	public double[] getSchnitteX()//Nst in der difffunktion = schnittpunkte der beiden auswertungen
	{
		return schnitte;
	}
	
	/**
	 * Liefert den Punkt wo der Erloes der beiden Funktionen maximal ist.<br>
	 * @return das Array mit dem Punkt; [0] = x, [1] = y;
	 */
	public double[] getMaxErlos()
	{
		return maxErlos;
	}
}